home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Font.C < prev    next >
C/C++ Source or Header  |  1992-04-27  |  8KB  |  389 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Font.h"
  6.  
  7. #include "Class.h"
  8. #include "Error.h"
  9. #include "String.h"
  10. #include "WindowSystem.h"
  11. #include "ObjArray.h"
  12. #include "OrdColl.h"
  13. #include "Env.h"
  14. #include "Math.h"
  15.  
  16. Font *gSysFont,
  17.      *gApplFont,
  18.      *gFixedFont;
  19.        
  20. class FontManager *gFontManager;
  21. bool freal;
  22.  
  23. static Symbol FontNames[12];
  24.  
  25. //---- Font --------------------------------------------------------------------
  26.  
  27. NewMetaImpl(Font,Object, (TA(cw), TE(face), T(size), T(ils), T(ht), T(bs), T(width), TP(ff)));
  28.  
  29. Font *new_Font(GrFont font, int size, GrFace face)
  30. { 
  31.     return gFontManager->MapFont(font, size, face);
  32. }
  33.  
  34. Font *new_Font(GrFont font, int size, GrFace face, bool)
  35. {
  36.     freal= TRUE;
  37.     Font *fp= gFontManager->MapFont(font, size, face);
  38.     freal= FALSE;
  39.     return fp;
  40. }
  41.  
  42. Font::Font(FontFamily *f, short ps, GrFace fc)
  43. {
  44.     ff= f;
  45.     size= ps;
  46.     face= fc;
  47.     if (ff)
  48.     ff->fmap->Add(this);
  49. }
  50.  
  51. Font *Font::WithFace(GrFace fc)
  52. {
  53.     return gFontManager->MapFont(Fid(), size, fc);
  54. }
  55.  
  56. Font *Font::WithSize(int sz)
  57. {
  58.     return gFontManager->MapFont(Fid(), sz, face);
  59. }
  60.  
  61. int Font::Width(register byte *s, register int l)
  62. {
  63.     register int w= 0;
  64.     
  65.     if (s) {
  66.     if (l < 0) {
  67.         while(*s)
  68.         w+= cw[*s++];
  69.     } else {
  70.         while(--l >= 0)
  71.         w+= cw[*s++];
  72.     }
  73.     }
  74.     return w;
  75. }
  76.  
  77. int Font::MaxWidth(int l)
  78. {
  79.     if (width < 0) {
  80.     register int i;
  81.     
  82.     width= 0;
  83.     for (i= 0; i< 255; i++)
  84.         width= Math::Max((u_short)width, cw[i]);
  85.     }
  86.     return l*width;
  87. }
  88.  
  89. Rectangle Font::BBox(register byte *s, register int l)
  90. {
  91.     register int w= 0;
  92.     
  93.     if (s == 0)
  94.     return gRect0;
  95.     if (l < 0) {
  96.     while(*s)
  97.         w+= cw[*s++];
  98.     } else {
  99.     while(--l >= 0)
  100.         w+= cw[*s++];
  101.     }
  102.     return Rectangle(0, ht, w, ht+bs);
  103. }
  104.  
  105. Metric Font::GetMetric(register byte *s, register int l)
  106. {
  107.     register int w= 0;
  108.     
  109.     if (s == 0)
  110.     return Metric(0);
  111.     if (l < 0) {
  112.     while(*s)
  113.         w+= cw[*s++];
  114.     } else {
  115.     while(--l >= 0)
  116.         w+= cw[*s++];
  117.     }
  118.     return Metric(w, Ascender()+Descender(), Ascender());
  119. }
  120.  
  121. Metric Font::GetMetric(byte c)
  122. {
  123.     return Metric(Width(c), Ascender()+Descender(), Ascender());
  124. }
  125.  
  126. Rectangle Font::BBox(register byte c, Point pos)
  127. {
  128.     return Rectangle(pos.x, pos.y-Ascender(), Width(c), Spacing());
  129. }
  130.  
  131. Point Font::AdjustString(register byte *s, Point p, GrVAdjust va, GrHAdjust ha)
  132. {
  133.     register int w= 0;
  134.     
  135.     if (ha) {
  136.     if (s)
  137.         while(*s)
  138.         w+= cw[*s++];
  139.     
  140.     switch (ha) {
  141.     case eAdjHRight:
  142.         p.x-= w;
  143.         break;
  144.     case eAdjHCenter:
  145.         p.x-= w/2;
  146.         break;
  147.     default:
  148.         break;
  149.     }
  150.     }
  151.     switch (va) {
  152.     case eAdjVBottom:
  153.     p.y-= bs;
  154.     break;
  155.     case eAdjVCenter:
  156.     p.y+= (ht-bs)/2;
  157.     break;
  158.     case eAdjVTop:
  159.     p.y+= ht;
  160.     break;
  161.     case eAdjVBase:
  162.     break;
  163.     }
  164.     return p;
  165. }
  166.  
  167. DevBitmap *Font::CharAsBitmap(byte, Point*)
  168. {
  169.     return 0;
  170. }
  171.  
  172. char *Font::AsString()
  173. {
  174.     return form("%s.%d.%s", Name(), Size(), gFontManager->StyleString(Face()));
  175. }
  176.  
  177. u_long Font::Hash()
  178. {
  179.     return (u_long) Fid();
  180. }
  181.  
  182. bool Font::IsEqual(Object *op)
  183. {
  184.     return op->IsKindOf(Font) && ((Font*)op)->Size() == Size()
  185.                         && ((Font*)op)->Face() == Face();
  186. }
  187.  
  188. OStream& Font::PrintOn(OStream &s)
  189. {
  190.     return s << FontNames[Fid()] SP << Size() SP << (int)Face() SP;
  191. }
  192.  
  193. Object *Font::ReadAndMap(IStream &s)
  194. {
  195.     int size;
  196.     GrFace face;
  197.     Symbol name;
  198.     s >> name >> size >> Enum(face);
  199.     return new_Font(gFontManager->NameToId(name.AsString()), size, face);
  200. }
  201.  
  202. //---- FontManager -------------------------------------------------------------
  203.  
  204. NewMetaImpl(FontManager,Object, (TP(fmap)));
  205.  
  206. FontManager::FontManager()
  207. {
  208.     fmap= new ObjArray;
  209.     
  210.     FontNames[0]= Symbol("Times");
  211.     FontNames[1]= Symbol("Helvetica");
  212.     FontNames[2]= Symbol("Courier");
  213.     FontNames[3]= Symbol("Symbol");
  214.     FontNames[4]= Symbol("Chicago");
  215.     FontNames[5]= Symbol("Avantgarde");
  216.     FontNames[6]= Symbol("Bookman");
  217.     FontNames[7]= Symbol("Schoolbook");
  218.     FontNames[8]= Symbol("NarrowHelvetica");
  219.     FontNames[9]= Symbol("Palatino");
  220.     FontNames[10]= Symbol("ZapfChancery");
  221.     FontNames[11]= Symbol("ZapfDingbats");
  222. }
  223.  
  224. FontManager::~FontManager()
  225. {
  226.     if (fmap) {
  227.     fmap->FreeAll();
  228.     SafeDelete(fmap);
  229.     }
  230. }
  231.  
  232. bool FontManager::Init()
  233. {
  234.     int size= Env::GetValue("Font.Size", 12);
  235.     GrFont fid= gFontManager->NameToId(Env::GetValue("Font.Sys", "Chicago"));
  236.     gSysFont= new_Font(fid, size);
  237.     fid= gFontManager->NameToId(Env::GetValue("Font.Appl", "Helvetica"));
  238.     gApplFont= new_Font(fid, size);
  239.     fid= gFontManager->NameToId(Env::GetValue("Font.Fixed", "Courier"));
  240.     gFixedFont= new_Font(fid, size);
  241.     return FALSE;
  242. }
  243.  
  244. FontFamily *FontManager::MapFamily(GrFont fid)
  245. {
  246.     FontFamily *fm;
  247.     
  248.     if ((fm= (FontFamily*) fmap->At(fid)) == 0) {
  249.     if (fid < eFontTimes || fid > eFontDingbats)
  250.         return (FontFamily*) fmap->At(eFontChicago);
  251.     fmap->AtPutAndExpand(fid, fm= new FontFamily(fid));
  252.     }
  253.     return fm;
  254. }
  255.     
  256. Font *FontManager::MapFont(GrFont fid, int size, GrFace face)
  257. {
  258.     return MapFamily(fid)->MapSizeFace(size, face);
  259. }
  260.  
  261. Font *FontManager::MakeFont(FontFamily*, int, GrFace, bool)
  262. {
  263.     return 0;
  264. }
  265.     
  266. Font *FontManager::ScaleFont(FontFamily *ff, int size, GrFace face)
  267. {
  268.     Font *f;
  269.     int facebit;
  270.  
  271.     if (face != eFacePlain) {
  272.     for (facebit= eFaceShadow; facebit; facebit >>= 1) {
  273.         if (face & facebit) {
  274.         face= (GrFace) (face & ~facebit);
  275.         return ff->MapSizeFace(size, face);
  276.         }
  277.     }
  278.     }
  279.     for (int i= 6; i < 24; i++) {
  280.     if ((size-i > 6) && (f= ff->MapSizeFace2(size-i, face)))
  281.         return f;
  282.     if ((size+i > 24) && (f= ff->MapSizeFace2(size+i, face)))
  283.         return f;
  284.     }
  285.     return 0;
  286. }
  287.  
  288. GrFont FontManager::NameToId(char *fontname)
  289. {
  290.     Symbol name(fontname);
  291.     for (int i= 0; i < sizeof(FontNames) / sizeof(FontNames[0]); i++)
  292.     if (FontNames[i] == name)
  293.         return (GrFont)i;
  294.     return (GrFont)-1;
  295. }
  296.  
  297. char *FontManager::IdToName(GrFont fid)
  298. {
  299.     if (fid >= 0 && fid < sizeof(FontNames) / sizeof(FontNames[0]))
  300.     return FontNames[fid].AsString();
  301.     return 0;
  302. }
  303.  
  304. char *FontManager::StyleString(GrFace face)
  305. {
  306.     static char buf[20];
  307.     char *cp= buf;
  308.     if (face == eFacePlain)
  309.     *cp++= 'r';
  310.     else {
  311.     if (face & eFaceBold)
  312.         *cp++= 'b';
  313.     if (face & eFaceItalic)
  314.         *cp++= 'i';
  315.     if (face & eFaceUnderline)
  316.         *cp++= 'u';
  317.     if (face & eFaceOutline)
  318.         *cp++= 'o';
  319.     if (face & eFaceShadow)
  320.         *cp++= 's';
  321.     }
  322.     *cp= '\0';
  323.     return buf;
  324. }
  325.  
  326. void FontManager::CollectParts(class Collection *col)
  327. {
  328.     col->Add(fmap);
  329. }
  330.  
  331. //---- FontFamily --------------------------------------------------------------
  332.  
  333. NewMetaImpl(FontFamily,Object, (TE(fid), TB(fixed), TP(fmap)));
  334.  
  335. FontFamily::FontFamily(GrFont f)
  336. {
  337.     fid= f;
  338.     fmap= new OrdCollection;
  339. }
  340.  
  341. FontFamily::~FontFamily()
  342. {
  343.     if (fmap) {
  344.     fmap->FreeAll();
  345.     SafeDelete(fmap);
  346.     }
  347. }
  348.  
  349. char *FontFamily::Name()
  350. {
  351.     return FontNames[fid].AsString();
  352. }
  353.  
  354. Font *FontFamily::MapSizeFace2(int size, GrFace face, bool dflt)
  355. {
  356.     Iter next(fmap);
  357.     register Font *fp;
  358.     
  359.     // if (! freal) {
  360.     while (fp= (Font*) next())
  361.     if (fp->Size() == size && fp->Face() == face)
  362.         return fp;
  363.     // }
  364.     freal= FALSE;
  365.     return gFontManager->MakeFont(this, size, face, dflt);
  366. }
  367.  
  368. Font *FontFamily::MapSizeFace(int size, GrFace face)
  369. {
  370.     Font *f;
  371.     
  372.     if (f= MapSizeFace2(size, face))
  373.     return f;
  374.     if (f= gFontManager->ScaleFont(this, size, face))
  375.     return f;
  376.     return MapSizeFace2(0, face, TRUE);
  377. }
  378.  
  379. void FontFamily::InspectorId(char *buf, int bufSize)
  380. {
  381.     strncpy(buf, Name(), bufSize);
  382. }
  383.  
  384. void FontFamily::CollectParts(class Collection *col)
  385. {
  386.     col->Add(fmap);
  387. }
  388.  
  389.